package com.example.springboottest.example.blockqueue;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

/**
 * 既然阻塞队列可以实现线程之间的等待，那么我们就可以通过两个具有1个空间的阻塞队列可以实现线程的同步，
 * 两个方法要实现同步，由于定义的两个阻塞队列都是容量为1，所以只要有一个queue1.put(1);
 * 那么sub()方法就必须等待，只有当main()方法中queue1.take();以后sub()方法才可以继续进行
 */
public class BlockingQueueTest2 {
    static BlockingQueue<Integer> queue1 = new ArrayBlockingQueue<Integer>(1);
    static BlockingQueue<Integer> queue2 = new ArrayBlockingQueue<Integer>(1);

    static Runnable mainRunnable = () -> {
        try {
            int num = 0;
            while (true) {
                queue2.put(1);
                System.out.println("main thread queue2.put");

                if (++num % 5 == 0)
                    Thread.sleep(5 * 1000);

                queue1.take();
                System.out.println("main thread queue1.take");
            }
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
    };

    static Runnable subRunnable = () -> {
        try {
            while (true) {
                queue1.put(1);
                System.out.println("sub thread 执行了queue1.put");

                queue2.take();
                System.out.println("sub thread 执行了queue2.take");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    };

    public static void main(String[] args) {
        new Thread(mainRunnable).start();
        new Thread(subRunnable).start();
    }
}